home *** CD-ROM | disk | FTP | other *** search
/ internet.au CDrom 42 / NETCD42.iso / chat / mac / snak.hqx / Snak 2.0b4 / Scripts / pp-dcc.irc < prev    next >
Encoding:
Text File  |  1996-03-22  |  24.9 KB  |  860 lines
  1. # ########################################################################## #
  2. #                      PurePak - The sequel to TextBox                       #
  3. #                          A -+ TEXT +- production                           #
  4. # ########################################################################## #
  5. # Author: Crypt Keeper [ckeeper@axiom.access.one.net] (CKeeper on IRC)
  6. # Version 2.07
  7. #
  8. # This script requires at least ircII2.2.9 (Unix) or a fully ircII compatible
  9. # client.  It has only been tested under Unix with ircII2.2.9 and ircII2.8.2.
  10. #
  11. # If you edit this file, you must edit it with a Unix text editor or use
  12. # utilities like dos2unix/unix2dos to convert it to DOS to edit and then
  13. # back to Unix.  If it is edited in a DOS text editor it will be corrupted.
  14. #
  15. # PurePak version 2.07 IRC script
  16. # Copyright (C) 1995
  17. #
  18. # This program is free software; you can redistribute it and/or modify
  19. # it under the terms of the GNU General Public License as published by
  20. # the Free Software Foundation; either version 1, or (at your option)
  21. # any later version.
  22. #
  23. # This program is distributed in the hope that it will be useful,
  24. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  25. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26. # GNU General Public License for more details.
  27. #
  28. # You should have received a copy of the GNU General Public License
  29. # along with this program; if not, write to the Free Software
  30. # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31. # ########################################################################## #
  32.  
  33. EVAL ^if (!(PPVERS)) {/echo *** This is not a stand-alone script, it must be loaded after purepak.irc;//exit}
  34.  
  35. # DCC fileserver/manager script
  36. @ PP.DCC = 1
  37.  
  38. # ----------------------------------------------------------------------------
  39. # DCC alias
  40. # ----------------------------------------------------------------------------
  41.  
  42. alias xdcc {/dcc $*}
  43. alias dcc {
  44.     if ([$0])
  45.     {
  46.         if (match($0 SEND GET RAW TALK CHAT OFFER DOFFER LIST PLIST NOTICE DLDIR FRIENDS AUTOGET LOAD SAVE CLOSE LIMIT RENAME TMSG NOTE SERVER TIMEOUT QUEUEING PUBLIST AUTOCHAT))
  47.         {
  48.             if (match($0 RAW TALK RENAME TMSG SEND CHAT)) {//dcc $*}
  49.             if (match($0 CLOSE OFFER DOFFER LIST PLIST NOTICE DLDIR AUTOGET FRIENDS LOAD SAVE GET LIMIT NOTE SERVER TIMEOUT QUEUEING PUBLIST AUTOCHAT)) {/dcc.ucmd.$0 $1-}
  50.         } {/echo *** Unrecognized DCC command, type /pphelp dcc}
  51.     }
  52.     {
  53.         if (!PP.EPIC)
  54.         {
  55.             dcc.updatestatus
  56.             @ GDCCS = 0
  57.             if (DCC.GETS)
  58.             {
  59.                 @ GDCCS = 1
  60.                 echo *** Incoming files: From      Status      Read       Filename
  61.                 foreach DCC.GETS AA {
  62.                     EVAL ^foreach DCC.GETS.$AA XY {
  63.                         @ NK = decode($AA)
  64.                         if (word(0 $DCC.GETS[$AA][$XY]) == [W]) {@ ST = [Waiting]} {@ ST = [In Progress]}
  65.                         @ BT = word(2 $DCC.GETS[$AA][$XY])
  66.                         echo ***                 $[9]NK $[11]ST $[10]BT $right(24 $decode($XY))
  67.                     }
  68.                 }
  69.             }
  70.             if (DCC.SENDS)
  71.             {
  72.                 @ GDCCS = 1
  73.                 echo *** Outgoing files: To        Status      Written    Filename
  74.                 foreach DCC.SENDS AA {
  75.                     EVAL ^foreach DCC.SENDS.$AA XY {
  76.                         @ NK = decode($AA)
  77.                         if (word(0 $DCC.SENDS[$AA][$XY]) == [W]) {@ ST = [Waiting]} {@ ST = [In Progress]}
  78.                         @ BT = word(1 $DCC.SENDS[$AA][$XY])
  79.                         echo ***                 $[9]NK $[11]ST $[10]BT $right(24 $decode($XY))
  80.                     }
  81.                 }
  82.             }
  83.             if (DCC.CHATS)
  84.             {
  85.                 foreach DCC.CHATS AA {
  86.                     if (word(0 $DCC.CHATS[$AA]) == [W]) {/echo *** DCC CHAT request to $decode($AA) not established (waiting)}
  87.                     if (word(0 $DCC.CHATS[$AA]) == [O]) {/echo *** DCC CHAT offered from $decode($AA)}
  88.                     if (word(0 $DCC.CHATS[$AA]) == [A]) {/echo *** DCC CHAT active to $decode($AA)}
  89.                 }
  90.                 @ GDCCS = 1
  91.             }
  92.             if (GDCCS) {^assign -XY}
  93.             {/echo *** No active DCC CHAT, SEND, or GET connections}
  94.             ^assign -GDCCS
  95.         } {//dcc}
  96.     }
  97. }
  98.  
  99. EVAL ^if (!PP.SET.DCCDLDIR) {@ PP.SET.DCCDLDIR = [.]}
  100. EVAL ^if (!PP.SET.DCCAUTOGET) {@ PP.SET.DCCAUTOGET = [OFF]}
  101. EVAL ^if (!PP.SET.DCCFLAUTOGET) {@ PP.SET.DCCFLAUTOGET = [ON]}
  102. EVAL ^if (!PP.SET.DCCLIMIT) {@ PP.SET.DCCLIMIT = [-1]}
  103. EVAL ^if (!PP.SET.DCCSERVER) {@ PP.SET.DCCSERVER = [ON]}
  104. EVAL ^if (!PP.SET.DCCTIMEOUT) {@ PP.SET.DCCTIMEOUT = 90}
  105. EVAL ^if (!PP.SET.DCCPUBLIST) {@ PP.SET.DCCPUBLIST = [ON]}
  106. EVAL ^if (!PP.SET.DCCQUEUEING) {@ PP.SET.DCCQUEUEING = [ON]}
  107. EVAL ^if (!PP.SET.DCCAUTOCHAT) {@ PP.SET.DCCAUTOCHAT = [OFF]}
  108.  
  109. # ----------------------------------------------------------------------------
  110. # /dcc functions
  111. # ----------------------------------------------------------------------------
  112.  
  113. # /dcc autochat
  114. alias dcc.ucmd.autochat {
  115.     if (match($0 ON OFF)) {@ PP.SET.DCCAUTOCHAT = toupper($0)}
  116.     echo *** Auto accept DCC CHAT requests is now ${PP.SET.DCCAUTOCHAT}
  117. }
  118. # /dcc queueing
  119. alias dcc.ucmd.queueing {
  120.     if (match($0 ON OFF)) {@ PP.SET.DCCQUEUEING = toupper($0)}
  121.     echo *** Queueing of send requests if all slots are full is now ${PP.SET.DCCQUEUEING}
  122. }
  123. # /dcc server
  124. alias dcc.ucmd.server {
  125.     if (match($0 ON OFF)) {@ PP.SET.DCCSERVER = toupper($0)}
  126.     echo *** DCC server is now ${PP.SET.DCCSERVER}
  127. }
  128. # /dcc publist
  129. alias dcc.ucmd.publist {
  130.     if (match($0 ON OFF)) {@ PP.SET.DCCPUBLIST = toupper($0)}
  131.     echo *** Allow public CTCP XDCC LISTs is now ${PP.SET.DCCPUBLIST}
  132. }
  133. # /dcc note
  134. alias dcc.ucmd.note {
  135.     if ([$0]) {^if ([$0] != [-]) {@ DCC.NOTE = [$*]} {^assign -DCC.NOTE}}
  136.     if (DCC.NOTE) {/echo *** DCC offer list note: $DCC.NOTE} {/echo *** No DCC offer list note set}
  137. }
  138. # /dcc notice
  139. alias dcc.ucmd.notice {
  140.     if (C)
  141.     {
  142.         EVAL @ SEND_MSG = [ACTION - Files offered: Type /msg $N xdcc list for a list.]
  143.         ^pp.listmsg PRIVMSG $mychannels()
  144.         ^assign -SEND_MSG
  145.         echo * $N - Files offered! Type /msg $N xdcc list for a list.
  146.     } {/echo *** You aren't on any channels}
  147. }
  148. # /dcc offer
  149. alias dcc.ucmd.offer {
  150.     ^input "Enter filename(s) to offer: " if (1) {
  151.         if ([$0])
  152.         {
  153.             @ IDX = 0
  154.             while (word($IDX $*))
  155.             {
  156.                 if (fileexists($word($IDX $*))) {@ DCCFILS = DCCFILS##[$word($IDX $*) ]}
  157.                 {/echo *** File $word($IDX $*) does not exist or you have no permission to access}
  158.                 @ IDX = IDX + 1
  159.             }
  160.             if (DCCFILS)
  161.             {
  162.                 ^input "Enter a description for this pack: " if (1) {
  163.                     if ([$0])
  164.                     {
  165.                         @ IDX = 1
  166.                         while (DCCPACKS.FILES[$IDX]) {@ IDX = IDX + 1}
  167.                         @ DCCPACKS.FILES[$IDX] = DCCFILS
  168.                         @ DCCPACKS.DESC[$IDX] = [$*]
  169.                         @ DCCPACKS.STATS[$IDX] = [$W 0]
  170.                         echo *** Pack #$IDX added with files: ${DCCFILS}
  171.                         ^assign -IDX
  172.                         ^assign -DCCFILS
  173.                     }
  174.                     {
  175.                         ^assign -IDX
  176.                         ^assign -DCCFILS
  177.                         echo *** You must enter a description
  178.                     }
  179.                 }
  180.             }
  181.             {
  182.                 ^assign -IDX
  183.                 echo *** No files in pack!
  184.             }
  185.         } {/echo *** No files in pack!}
  186.     }
  187. }
  188. # /dcc doffer
  189. alias dcc.ucmd.doffer {
  190.     ^input "Enter pack number(s) to remove: " if (1) {
  191.         if ([$0])
  192.         {
  193.             @ AA = 0
  194.             while (word($AA $*))
  195.             {
  196.                 if (DCCPACKS.FILES[$word($AA $*)])
  197.                 {
  198.                     ^assign -DCCPACKS.FILES[$word($AA $*)]
  199.                     ^assign -DCCPACKS.DESC[$word($AA $*)]
  200.                     ^assign -DCCPACKS.STATS[$word($AA $*)]
  201.                     @ CTR = word($AA $*) + 1
  202.                     while (DCCPACKS.FILES[$CTR])
  203.                     {
  204.                         @ DCCPACKS.FILES[${CTR-1}] = DCCPACKS.FILES[$CTR]
  205.                         @ DCCPACKS.DESC[${CTR-1}] = DCCPACKS.DESC[$CTR]
  206.                         @ DCCPACKS.STATS[${CTR-1}] = DCCPACKS.STATS[$CTR]
  207.                         if (!(DCCPACKS.FILES[${CTR+1}]))
  208.                         {
  209.                             ^assign -DCCPACKS.FILES[$CTR]
  210.                             ^assign -DCCPACKS.DESC[$CTR]
  211.                             ^assign -DCCPACKS.STATS[$CTR]
  212.                         }
  213.                         @ CTR = CTR + 1
  214.                     }
  215.                     echo *** Pack #$word($AA $*) removed
  216.                 } {/echo *** There is no pack #$word($AA $*)}
  217.                 @ AA = AA + 1
  218.             }
  219.             ^assign -CTR
  220.         }
  221.     }
  222. }
  223. # /dcc list
  224. alias dcc.ucmd.list {
  225.     if (dcc.havepacks())
  226.     {
  227.         if (PP.SET.DCCLIMIT > 0) {/echo *** Files offered: [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  228.         {/echo *** Files offered:}
  229.         dcc.dolist 1 echo ***
  230.     } {/echo *** You have no files offered}
  231. }
  232. # /dcc save
  233. alias dcc.ucmd.save {
  234.     if ([$0])
  235.     {
  236.         @ LF = [$0]
  237.         exec -name rm $PP.SET.RMCMD $0
  238.         wait -CMD %rm if (1) {
  239.             if (PP.EPIC)
  240.             {
  241.                 @ FHANDLE = open($LF w)
  242.                 if (FHANDLE > 0) {/EVAL ^assign WC /write $FHANDLE}
  243.                 {/echo *** Could not open $LF}
  244.             }
  245.             {
  246.                 ^window new
  247.                 ^window hold_mode off
  248.                 ^window name WRITEDCC
  249.                 ^window logfile $LF
  250.                 ^window log on
  251.                 @ WC = [/xecho -WINDOW WRITEDCC]
  252.             }
  253.             $WC # PurePak DCC module offer file, written $stime($time())
  254.             foreach DCCPACKS.FILES AA {
  255.                 @ CT = 0
  256.                 @ DFILES = []
  257.                 while (word($CT $DCCPACKS.FILES[$AA]))
  258.                 {
  259.                     if (match(/* $word($CT $DCCPACKS.FILES[$AA]))) {@ DFILES = DFILES##[$word($CT $DCCPACKS.FILES[$AA]) ]}
  260.                     {@ DFILES = DFILES##[$word(0 $DCCPACKS.STATS[$AA])/$word($CT $DCCPACKS.FILES[$AA]) ]}
  261.                     @ CT = CT + 1
  262.                 }
  263.                 $WC ^dcc.addpack $encode($DFILES) $encode($DCCPACKS.DESC[$AA])
  264.             }
  265.             ^assign -CT
  266.             ^assign -DFILES
  267.             if (DCC.NOTE) {$WC ^dcc.ucmd.note $DCC.NOTE}
  268.             if (PP.EPIC)
  269.             {
  270.                 comment $close($FHANDLE)
  271.                 ^assign -FHANDLE
  272.             }
  273.             {
  274.                 ^window log off
  275.                 ^window kill
  276.             }
  277.             echo *** Current pack data written to $LF
  278.             ^assign -LF
  279.             ^assign -WC
  280.         }
  281.     } {/dcc.ucmd.save purepak.dcc}
  282. }
  283. # /dcc load
  284. alias dcc.ucmd.load {^if ([$0]) {//load $0} {//load purepak.dcc}}
  285. # /dcc plist
  286. alias dcc.ucmd.plist {
  287.     if (dcc.havepacks())
  288.     {
  289.         say Files offered: Type /msg $N xdcc send #N to get pack #N
  290.         if (PP.SET.DCCLIMIT > 0) {/say [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  291.         dcc.dolist 0 say
  292.     } {/echo *** You have no files offered}
  293. }
  294. # /dcc dldir
  295. alias dcc.ucmd.dldir {
  296.     if ([$0])
  297.     {
  298.         @ PP.SET.DCCDLDIR = [$0]
  299.         echo *** DCC download directory is now $0
  300.     } {/echo *** DCC download directory is now ${PP.SET.DCCDLDIR}}
  301. }
  302. # /dcc limit
  303. alias dcc.ucmd.limit {
  304.     if ([$0])
  305.     {
  306.         if (([$0] == [NONE])||([$0] == [OFF])) {@ PP.SET.DCCLIMIT = [-1]}
  307.         {
  308.             if (!isalpha($0)) {@ PP.SET.DCCLIMIT = [$0]}
  309.             {/echo *** Must be a numerical value}
  310.         }
  311.     }
  312.     if (PP.SET.DCCLIMIT == [-1]) {/echo *** DCC autosend file limit is now UNLIMITED}
  313.     {/echo *** DCC autosend file limit is now ${PP.SET.DCCLIMIT}}
  314. }
  315. # /dcc limit
  316. alias dcc.ucmd.timeout {
  317.     if ([$0])
  318.     {
  319.         if (([$0] == [NONE])||([$0] == [OFF])) {@ PP.SET.DCCTIMEOUT = [-1]}
  320.         {
  321.             if (!isalpha($0)) {@ PP.SET.DCCTIMEOUT = [$0]}
  322.             {/echo *** Must be a numerical value}
  323.         }
  324.     }
  325.     if (PP.SET.DCCTIMEOUT == [-1]) {/echo *** DCC autosend timeout is now UNLIMITED}
  326.     {/echo *** DCC autosend timeout is now ${PP.SET.DCCTIMEOUT}}
  327. }
  328. # /dcc autoget
  329. alias dcc.ucmd.autoget {
  330.     if (match($0 ON OFF)) {@ PP.SET.DCCAUTOGET = toupper($0)}
  331.     echo *** DCC autoget is now ${PP.SET.DCCAUTOGET}
  332. }
  333. # /dcc friends
  334. alias dcc.ucmd.friends {
  335.     if (match($0 ON OFF)) {@ PP.SET.DCCFLAUTOGET = toupper($0)}
  336.     echo *** DCC autoget from people in friends list is now ${PP.SET.DCCFLAUTOGET}
  337. }
  338. # /dcc get
  339. alias dcc.ucmd.get {
  340.     if ([$0])
  341.     {
  342.         if ([$1])
  343.         {
  344.             @ AA = 1
  345.             ^on ^window "% *No file offered in SEND*" {@ AA = 0}
  346.             //dcc get $0 $1
  347.             if (!AA) {/echo *** File $1 not offered by $0}
  348.         }
  349.         {
  350.             if ([$0])
  351.             {
  352.                 dcc.updatestatus
  353.                 @ FL = 0
  354.                 foreach DCC.GETS AA {
  355.                     if (toupper($decode($AA)) == toupper($0))
  356.                     {
  357.                         @ FL = 1
  358.                         EVAL foreach DCC.GETS.$AA XY {//dcc get $0 $decode($XY)}
  359.                         ^assign -XY
  360.                         echo *** Got all files offered by $0
  361.                     }
  362.                 }
  363.                 if (!FL) {/echo *** No files offered by $0}
  364.                 ^assign -FL
  365.             }
  366.             {
  367.                 dcc.updatestatus
  368.                 if (DCC.GETS)
  369.                 {
  370.                     foreach DCC.GETS AA {
  371.                         EVAL foreach DCC.GETS.$AA XY {//dcc get $decode($AA) $decode($XY)}
  372.                         ^assign -XY
  373.                     }
  374.                 } {/echo *** No files offered}
  375.             }
  376.         }
  377.     } {/echo *** /dcc get [<nick>] [<file>]}
  378. }
  379. # /dcc close
  380. alias dcc.ucmd.close {
  381.     if (match($0 RAW TALK CHAT RAW_LISTEN RAW_LIS)) {//dcc close $*}
  382.     {
  383.         @ AA = 0
  384.         if ([$0] == [SEND])
  385.         {
  386.             if ([$1])
  387.             {
  388.                 if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}
  389.                 if ([$2]) {//dcc close $*}
  390.                 {
  391.                     EVAL ^repeatcmd 30 //^dcc close send $1
  392.                     echo *** All DCC SENDs to $1 closed
  393.                 }
  394.             } {/echo *** /dcc close send <nick> [<file>]}
  395.             @ AA = 1
  396.         }
  397.         if ([$0] == [GET])
  398.         {
  399.             if ([$1])
  400.             {
  401.                 if ([$2]) {//dcc close $*}
  402.                 {
  403.                     EVAL ^repeatcmd 30 //^dcc close get $1
  404.                     echo *** All DCC GETs from $1 closed
  405.                 }
  406.             } {/echo *** /dcc close get <nick> [<file>]}
  407.             @ AA = 1
  408.         }
  409.         if (!AA) {/echo *** /dcc close <type> <nick> [<arguments>]}
  410.     }
  411. }
  412.  
  413. # ----------------------------------------------------------------------------
  414. # ON hooks and internal procedures
  415. # ----------------------------------------------------------------------------
  416.  
  417. on ^ctcp "% % DCC SEND % % % *" {
  418.     if (([$6] > 1024)&&([$6] < 65535))
  419.     {
  420.         if (!ischannel($1))
  421.         {
  422.             if ((!!(PP.SET.DCCDLDIR))&&(PP.SET.DCCDLDIR != [.])) {//dcc rename $0 $4 ${PP.SET.DCCDLDIR}/$4}
  423.             if (PP.SET.DCCAUTOGET == [ON])
  424.             {
  425.                 echo *** Autogetting DCC SEND $4 from $0
  426.                 ^timer 2 //dcc get $0 $4
  427.             }
  428.             {
  429.                 if (PP.SET.DCCFLAUTOGET == [ON])
  430.                 {
  431.                     foreach PP.FRIENDS AA {@ FNDS = FNDS##[ $PP.FRIENDS[$AA]]}
  432.                     if (rmatch($0!$USERHOST() $FNDS))
  433.                     {
  434.                         echo *** Autogetting DCC SEND $4 from $0\; $0 is on your friends list
  435.                         //dcc get $0 $4
  436.                     }
  437.                     ^assign -FNDS
  438.                 }
  439.             }
  440.         } {/echo *** Strange: $0 sent a DCC SEND request adressed to channel $1}
  441.     }
  442.     {
  443.         ^timer 1 /echo *** DCC SEND request from $0 using priviledged port detected\; ignored (bomb?)
  444.         //dcc close get $0 $4
  445.     }
  446. }
  447. on ^ctcp "% % DCC CHAT % % *" {
  448.     if (([$6] < 1024)||([$6] > 65535))
  449.     {
  450.         ^timer 1 /echo *** DCC CHAT request from $0 using priviledged port detected\; ignored (bomb?)
  451.         //dcc close chat $0
  452.         //dcc close chat $0
  453.     }
  454.     {
  455.         if (PP.SET.DCCAUTOCHAT == [ON])
  456.         {
  457.             ^timer 1 /echo *** Autogetting DCC CHAT request from $0
  458.             //dcc chat $0
  459.         }
  460.         {
  461.             if (PP.SET.DCCFLAUTOGET == [ON])
  462.             {
  463.                 foreach PP.FRIENDS AA {@ FNDS = FNDS##[ $PP.FRIENDS[$AA]]}
  464.                 if (rmatch($0!$USERHOST() $FNDS))
  465.                 {
  466.                     ^timer 1 /echo *** Autogetting DCC CHAT request from $0\; $0 is on your friends list
  467.                     //dcc chat $0
  468.                 }
  469.                 ^assign -FNDS
  470.             }
  471.         }
  472.     }
  473. }
  474.  
  475. # We use a raw_irc for on msg to prevent a beep if BEEP_ON_MSG is set
  476. on ^raw_irc "% PRIVMSG % :XDCC *" {
  477.     if (!ischannel($2))
  478.     {
  479.         if (PP.SET.DCCSERVER == [ON]) {/dcc.msg $nickonly($0) $N $mid(${index(! $0)+1} 1000 $0) $4-}
  480.     }
  481.     {
  482.         if ([$2] == C) {/xecho -LEVEL PUBLIC <$nickonly($0)> $strip(: $3) $4-}
  483.         {/xecho -LEVEL PUBLIC <$nickonly($0):$2> $strip(: $3) $4-}
  484.     }
  485. }
  486. on ^ctcp "% % XDCC *" {^if (PP.SET.DCCSERVER == [ON]) {/dcc.msg $0 $1 $USERHOST() $3-}}
  487. alias dcc.msg {
  488.     if (right(10 $2) != LASTDCCER)
  489.     {
  490.         if (ischannel($1))
  491.         {
  492.             if (match($3 SEND LIST HELP VERSION LSPACK))
  493.             {
  494.                 if ([$3] == [LIST])
  495.                 {
  496.                     if (PP.SET.DCCPUBLIST == [ON])
  497.                     {
  498.                         if (dcc.havepacks()) {/dcc.msg $0 $N $2-}
  499.                     } {/echo *** $0 request for DCC LIST to everyone in $1 ignored}
  500.                 }
  501.                 {
  502.                     echo *** $0 request for DCC $toupper($3) to everyone in $1 ignored\; only LIST is allowed globally
  503.                     //^notice $0 Only DCC LISTs are allowed globally
  504.                 }
  505.             }
  506.             {
  507.                 echo *** Invalid DCC server command from $0 to $1
  508.                 //^notice $0 Unknown DCC server command\; type /msg $N XDCC HELP
  509.             }
  510.         }
  511.         {
  512.             if (match($3 SEND LIST HELP VERSION LSPACK)) {/dcc.mcmd.$3 $0 $2 $4-}
  513.             {
  514.                 echo *** Invalid DCC server command from $0
  515.                 //^notice $0 Unknown DCC server command\; type /msg $N XDCC HELP
  516.             }
  517.         }
  518.     }
  519.     if (!LASTDCCER) {^timer 3 ^assign -LASTDCCER}
  520.     @ LASTDCCER = right(10 $2)
  521. }
  522.  
  523. # Updates DCC status variables by capturing /dcc's output
  524. # Doesn't work on EPIC clients :P
  525. alias dcc.updatestatus {
  526.     ^on ^window "% Type*Nick*Status*Start*time*Sent*Read*Arguments*" {}
  527.     ^on ^window "% SEND *" {
  528.         if ([$3] == [Waiting]) {@ DCC.SENDS[$encode($2)][$encode($6)] = [W $4 $5]} {@ DCC.SENDS[$encode($2)][$encode($10)] = [A $8 $9]}
  529.         @ DCC.SENDS = 1
  530.     }
  531.     ^on ^window "% GET *" {
  532.         if ([$3] == [Offered]) {@ DCC.GETS[$encode($2)][$encode($6)] = [W $4 $5]} {@ DCC.GETS[$encode($2)][$encode($10)] = [A $8 $9]}
  533.         @ DCC.GETS = 1
  534.     }
  535.     ^on ^window "% RAW *" {}
  536.     ^on ^window "% CHAT *" {
  537.         if ([$3] == [Waiting]) {@ DCC.CHATS[$encode($2)] = [W $4 $5]}
  538.         {
  539.             if ([$3] == [Offered]) {@ DCC.CHATS[$encode($2)] = [O $4 $5]} {@ DCC.CHATS[$encode($2)] = [A $8 $9]}
  540.         }
  541.         @ DCC.CHATS = 1
  542.     }
  543.     ^on ^window "% RAW_LIS *raw_listen*" {}
  544.     ^on ^window "% TALK *" {}
  545.     foreach DCC.SENDS AA {/EVAL ^foreach DCC.SENDS.$AA BB {^assign -DCC.SENDS[$AA][$BB]}}
  546.     foreach DCC.GETS AA {/EVAL ^foreach DCC.GETS.$AA BB {^assign -DCC.GETS[$AA][$BB]}}
  547.     foreach DCC.CHATS AA {^assign -DCC.CHATS[$AA]}
  548.     ^assign -DCC.SENDS
  549.     ^assign -DCC.GETS
  550.     ^assign -DCC.CHATS
  551.     ^assign -BB
  552.     //dcc
  553.     ^on window - "% TALK *"
  554.     ^on window - "% CHAT *"
  555.     ^on window - "% RAW *"
  556.     ^on window - "% GET *"
  557.     ^on window - "% RAW_LIS *raw_listen*"
  558.     ^on window - "% Type*Nick*Status*Start*time*Sent*Read*Arguments*"
  559.     ^on window - "% SEND *"
  560. }
  561.  
  562. # Executed when a saved pack file loads
  563. alias dcc.addpack {
  564.     @ FILZ = decode($0)
  565.     @ AA = 0
  566.     while (word($AA $FILZ))
  567.     {
  568.         if (!fileexists($word($AA $FILZ)))
  569.         {
  570.             ^delword $word($AA $FILZ) $FILZ
  571.             echo *** LOAD: file $word($AA $FILZ) does not exist, removed from pack
  572.             @ FILZ = NLIST
  573.             ^assign -NLIST
  574.         }
  575.         @ AA = AA + 1
  576.     }
  577.     if ([$#FILZ] > 0)
  578.     {
  579.         @ IDX = 1
  580.         while (DCCPACKS.FILES[$IDX]) {@ IDX = IDX + 1}
  581.         @ DCCPACKS.FILES[$IDX] = FILZ
  582.         @ DCCPACKS.DESC[$IDX] = decode($1)
  583.         @ DCCPACKS.STATS[$IDX] = [$W 0]
  584.         echo *** Pack #$IDX loaded with files: $FILZ
  585.         echo ***   - Description: $decode($1)
  586.         ^assign -IDX
  587.     } {/echo *** Pack not restored: no files}
  588.     ^assign -FILZ
  589. }
  590.  
  591. # Executed whenever the user changes nicks with /nick
  592. alias dcc.onnick {
  593.     if ([$0])
  594.     {
  595.         @ DCC.MYNICK = [$0]
  596.         EVAL ^on raw_irc - "${N}!% PRIVMSG $N :DCC SEND **"
  597.         EVAL ^on ^raw_irc "$0!% PRIVMSG $0 :DCC SEND **" {
  598.             @ DCC.SINT.FNAME = [$5]
  599.             @ DCC.SINT.FSIZE = strip( $8)
  600.             //^dcc close send $N
  601.             //^dcc close get $N
  602.             $DCC.ONREPCMD
  603.         }
  604.     }
  605. }
  606. EVAL ^on ^raw_irc "${N}!% PRIVMSG $N :DCC SEND **" {
  607.     @ DCC.SINT.FNAME = [$5]
  608.     @ DCC.SINT.FSIZE = strip( $8)
  609.     //^dcc close send $N
  610.     //^dcc close get $N
  611.     $DCC.ONREPCMD
  612. }
  613. @ DCC.ONREPCMD = [/dcc.norepcmd]
  614. alias dcc.norepcmd {
  615.     @ DCC.FSIZES[$encode($tolower($DCC.SINT.FNAME))] = DCC.SINT.FSIZE
  616.     ^assign -DCC.SINT.FNAME
  617.     ^assign -DCC.SINT.FSIZE
  618. }
  619.  
  620. # Checks to see if a file exists by trapping window output from a DCC SEND
  621. # to yourself.
  622. alias fileexists {
  623.     @ EXISTS = 1
  624.     ^on ^window "% *Cannot access*" {@ EXISTS = 0}
  625.     ^on ^window * {}
  626.     //dcc send $N $0
  627.     ^on window - "% *Cannot access*"
  628.     ^on window - *
  629.     @ FUNCTION_RETURN = EXISTS
  630.     ^assign -EXISTS
  631. }
  632.  
  633. # args=<files>, returns sum of all file sizes, or 0 if a file's size isn't
  634. # saved in the buffer
  635. alias dcc.getpacksize {
  636.     @ PSIZE = 0
  637.     @ CT = 0
  638.     while ((!!word($CT $*))&&(PSIZE != [-1]))
  639.     {
  640.         @ FN = dcc.nameonly($word($CT $*))
  641.         if (DCC.FSIZES[$encode($tolower($FN))])
  642.         {
  643.             @ PSIZE = PSIZE + DCC.FSIZES[$encode($tolower($FN))]
  644.         } {@ PSIZE = [-1]}
  645.         @ CT = CT + 1
  646.     }
  647.     ^assign -CT
  648.     ^assign -FN
  649.     if (PSIZE == [-1]) {@ FUNCTION_RETURN = 0}
  650.     {@ FUNCTION_RETURN = PSIZE}
  651.     ^assign -PSIZE
  652. }
  653.  
  654. # /dcc.dolist <show filenames too?> <command to do list>
  655. alias dcc.dolist {
  656.     @ MAXV = 0
  657.     foreach DCCPACKS.FILES AA {^if (AA > MAXV) {@ MAXV = AA}}
  658.     @ AA = 0
  659.     while (AA <= MAXV)
  660.     {
  661.         if (DCCPACKS.FILES[$AA]) 
  662.         {
  663.             $1- #${AA} - $DCCPACKS.DESC[$AA]
  664.             @ FILS = DCCPACKS.FILES[$AA]
  665.             EVAL $1-    + [$#FILS file(s)] [$dcc.getpacksize($FILS) bytes] [downloaded $word(1 $DCCPACKS.STATS[$AA]) times]
  666.             if ([$0]) {$1- #${AA} - Files: $FILS}
  667.         }
  668.         @ AA = AA + 1
  669.     }
  670.     ^assign -FILS
  671.     ^assign -MAXV
  672.     if (DCC.NOTE) {$1- * Note: $DCC.NOTE}
  673. }
  674.  
  675. # Returns true if you have files offered
  676. alias dcc.havepacks {
  677.     @ FUNCTION_RETURN = 0
  678.     foreach DCCPACKS.FILES BB {@ FUNCTION_RETURN = 1}
  679.     ^assign -BB
  680. }
  681.  
  682. # Queues a send for the timeout timer
  683. alias dcc.queuetimeout {@ DCC.TIMEOUTS[$encode($0)][$rand(99999)] = [$1 $2 $3]}
  684.  
  685. # Checks for DCC's that have timed out and runs queued DCC's
  686. on #^timer 22 * {
  687.     if (PP.SET.DCCTIMEOUT != [-1])
  688.     {
  689.         foreach DCC.TIMEOUTS AA {
  690.             EVAL ^foreach DCC.TIMEOUTS.$AA BB {
  691.                 if ([${time() - word(1 $DCC.TIMEOUTS[$AA][$BB])}] >= PP.SET.DCCTIMEOUT)
  692.                 {
  693.                     //^dcc close send $decode($AA) $word(2 $DCC.TIMEOUTS[$AA][$BB])
  694.                     //^dcc close send $decode($AA) ${W}/$word(0 $DCC.TIMEOUTS[$AA][$BB])
  695.                     if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}
  696.                     echo *** DCC SEND $word(2 $DCC.TIMEOUTS[$AA][$BB]) to $decode($AA) timed out
  697.                     //^notice $decode($AA) DCC SEND $word(2 $DCC.TIMEOUTS[$AA][$BB]) timed out
  698.                     ^assign -DCC.TIMEOUTS[$AA][$BB]
  699.                 }
  700.             }
  701.         }
  702.     }
  703.     if (PP.SET.DCCLIMIT != [-1])
  704.     {
  705.         while (dcc.gotqueue())
  706.         {
  707.             @ BB = 0
  708.             @ OLDESTQUEUE = 0
  709.             foreach DCC.SENDQUEUE AA {
  710.                 if ([${time() - AA}] > BB)
  711.                 {
  712.                     @ BB = time() - AA
  713.                     @ OLDESTQUEUE = AA
  714.                 }
  715.             }
  716.             echo *** Sending queued pack #$strip(# $word(2 $DCC.SENDQUEUE[$OLDESTQUEUE])) to $word(0 $DCC.SENDQUEUE[$OLDESTQUEUE])
  717.             ^alias echo {}
  718.             ^dcc.mcmd.send $DCC.SENDQUEUE[$OLDESTQUEUE]
  719.             ^alias -echo
  720.             ^assign -DCC.SENDQUEUE[$OLDESTQUEUE]
  721.         }
  722.         ^assign -OLDESTQUEUE
  723.     }
  724.     {
  725.         foreach DCC.SENDQUEUE AA {
  726.             echo *** Sending queued pack #$strip(# $word(2 $DCC.SENDQUEUE[$AA])) to $word(0 $DCC.SENDQUEUE[$AA])
  727.             ^alias echo {}
  728.             ^dcc.mcmd.send $DCC.SENDQUEUE[$AA]
  729.             ^alias -echo
  730.             ^assign -DCC.SENDQUEUE[$AA]
  731.         }
  732.     }
  733.     ^assign -BB
  734. }
  735.  
  736. # Returns true if files are queued and there are slots available
  737. alias dcc.gotqueue {
  738.     @ FUNCTION_RETURN = 0
  739.     foreach DCC.SENDQUEUE AB {^if (DCC.NSENDING < PP.SET.DCCLIMIT) {@ FUNCTION_RETURN = 1}}
  740.     ^assign -AB
  741. }
  742.  
  743. # Removes timeouts when sends are initiated
  744. on -window "% % DCC SEND connection to*established*" {
  745.     if (match(*[* $6)) {@ NIQ = left($index([ $6) $6)} {@ NIQ = [$6]}
  746.     foreach DCC.TIMEOUTS AA {^if (decode($AA) == NIQ) {^EVAL ^foreach DCC.TIMEOUTS.$AA BB {^assign -DCC.TIMEOUTS[$AA][$BB]}}}
  747.     ^assign -BB
  748.     ^assign -NIQ
  749. }
  750.  
  751. # Removes path from a filename
  752. alias dcc.nameonly {^if (match(*/* $0)) {@ FUNCTION_RETURN = mid(${rindex(/ $0)+1} 1000 $0)} {@ FUNCTION_RETURN = [$0]}}
  753.  
  754. # ----------------------------------------------------------------------------
  755. # User /msg command functions
  756. # ----------------------------------------------------------------------------
  757.  
  758. alias dcc.mcmd.version {
  759.     if (index(Y $PP.SET) == [-1])
  760.     {
  761.         //^notice $0 PurePak version $PPVERS DCC module
  762.         echo *** $0 [$strip( $1)] requested your version
  763.     }
  764. }
  765. alias dcc.mcmd.help {
  766.     //^notice $0 Available DCC server commands:
  767.     //^notice $0 HELP, LIST, SEND <#pack>, LSPACK <#pack>, VERSION
  768.     echo *** $0 [$strip( $1)] requested DCC server help
  769. }
  770. alias dcc.mcmd.list {
  771.     if (dcc.havepacks())
  772.     {
  773.         //^notice $0 Files available: Type /msg $N XDCC SEND #N to get pack #N
  774.         if (PP.SET.DCCLIMIT > 0) {//^notice $0 [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  775.         EVAL ^dcc.dolist 0 //^notice $0
  776.         echo *** $0 [$strip( $1)] requested a list of files offered
  777.     } {//^notice $0 No files offered}
  778. }
  779. alias dcc.mcmd.lspack {
  780.     if (DCCPACKS.FILES[$strip(# $2)])
  781.     {
  782.         //^notice $0 Files in pack #$strip(# $2)
  783.         @ AA = 0
  784.         while (word($AA $DCCPACKS.FILES[$strip(# $2)]))
  785.         {
  786.             //^notice $0   $dcc.nameonly($word($AA $DCCPACKS.FILES[$strip(# $2)])) [$dcc.getpacksize($word($AA $DCCPACKS.FILES[$strip(# $2)])) bytes]
  787.             @ AA = AA + 1
  788.         }
  789.         echo *** $0 [$strip( $1)] requested a list of files in pack #$strip(# $2)
  790.     } {//^notice $0 There is no pack #$strip(# $2)}
  791. }
  792. @ DCC.NSENDING = 0
  793. alias dcc.mcmd.send {
  794.     if (DCCPACKS.FILES[$strip(# $2)])
  795.     {
  796.         if ((DCC.NSENDING >= PP.SET.DCCLIMIT)&&(PP.SET.DCCLIMIT != [-1]))
  797.         {
  798.             if (PP.SET.DCCQUEUEING == [ON])
  799.             {
  800.                 @ ALREADY = 0
  801.                 foreach DCC.SENDQUEUE AA {
  802.                     if ((word(0 $DCC.SENDQUEUE[$AA]) == [$0])&&(word(2 $DCC.SENDQUEUE[$AA]) == [$2]))
  803.                     {
  804.                         //^notice $0 You already have a request for pack #$strip(# $2) queued
  805.                         @ ALREADY = 1
  806.                     }
  807.                 }
  808.                 if (!ALREADY)
  809.                 {
  810.                     @ DCC.SENDQUEUE[$time()] = [$*]
  811.                     echo *** DCC SEND request for pack #$strip(# $2) to $0 queued: no more slots available
  812.                     //^notice $0 No more DCC slots available: your request has been queued
  813.                 }
  814.                 ^assign -ALREADY
  815.             }
  816.             {
  817.                 //^notice $0 No more DCC slots available
  818.                 echo *** DCC SEND request for pack #$strip(# $2) to $0 denied: no more slots available
  819.             }
  820.         }
  821.         {
  822.             @ PACKNUM = strip(# $2)
  823.             //^notice $0 Sending you pack #$PACKNUM \(you will need $dcc.getpacksize($DCCPACKS.FILES[$PACKNUM]) bytes\)
  824.             //^notice $0 Type /dcc get $N <file> for each request received
  825.             @ CTR = 0
  826.             @ AA = word(1 $DCCPACKS.STATS[$PACKNUM])
  827.             @ DCCPACKS.STATS[$PACKNUM] = [$word(0 $DCCPACKS.STATS[$PACKNUM]) ${AA+1}]
  828.             while (word($CTR $DCCPACKS.FILES[$PACKNUM]))
  829.             {
  830.                 @ AA = word($CTR $DCCPACKS.FILES[$PACKNUM])
  831.                 if (!match(/* $AA))
  832.                 {
  833.                     //^dcc close send $0 $word(0 $DCCPACKS.STATS[$PACKNUM])/$AA
  834.                     //^dcc send $0 $word(0 $DCCPACKS.STATS[$PACKNUM])/$AA
  835.                     @ SF = [$word(0 $DCCPACKS.STATS[$PACKNUM])/$AA]
  836.                 }
  837.                 {
  838.                     //^dcc close send $0 $AA
  839.                     //^dcc send $0 $AA
  840.                     @ SF = AA
  841.                 }
  842.                 if (PP.SET.DCCTIMEOUT > 0) {^dcc.queuetimeout $0 $dcc.nameonly($AA) $time() $SF}
  843.                 @ DCC.NSENDING = DCC.NSENDING + 1
  844.                 if ((PP.SET.DCCLIMIT != [-1])&&(DCC.NSENDING > PP.SET.DCCLIMIT)) {@ DCC.NSENDING = PP.SET.DCCLIMIT}
  845.                 @ CTR = CTR + 1
  846.             }
  847.             ^assign -SF
  848.             ^assign -CTR
  849.             echo *** DCC pack #$PACKNUM sent to $0 [$strip( $1)]
  850.             ^assign -PACKNUM
  851.         }
  852.     } {//^notice $0 There is no pack #$strip(# $2)}
  853. }
  854. on -window "% % DCC SEND:% *completed*" {^if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}}
  855. on -window "% % DCC SEND:% *lost*" {^if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}}
  856.  
  857. # ----------------------------------------------------------------------------
  858.  
  859. EVAL ^if (!PP.SET.NOSTARTUP) {/echo -- PurePak DCC server module loaded}
  860.